

<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  <title>8. How-to discussions &mdash; LIGGGHTS v3.X documentation</title>
  

  
  
  
  

  

  
  
    

  

  
  
    <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
  

  

  
    <link rel="top" title="LIGGGHTS v3.X documentation" href="index.html"/>
        <link rel="next" title="9. Modifying &amp; extending LIGGGHTS(R)-PUBLIC" href="Section_modify.html"/>
        <link rel="prev" title="7. Packages" href="Section_packages.html"/> 

  
  <script src="_static/js/modernizr.min.js"></script>

</head>

<body class="wy-body-for-nav" role="document">

   
  <div class="wy-grid-for-nav">

    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
      <div class="wy-side-scroll">
        <div class="wy-side-nav-search">
          

          
            <a href="Manual.html" class="icon icon-home"> LIGGGHTS
          

          
          </a>

          
            
            
              <div class="version">
                v3.X
              </div>
            
          

          
<div role="search">
  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
  </form>
</div>

          
        </div>

        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
          
            
            
              
            
            
              <ul class="current">
<li class="toctree-l1"><a class="reference internal" href="Section_intro.html">1. Introduction</a></li>
<li class="toctree-l1"><a class="reference internal" href="Section_start.html">2. Getting Started</a></li>
<li class="toctree-l1"><a class="reference internal" href="Section_input_script.html">3. Input Script</a></li>
<li class="toctree-l1"><a class="reference internal" href="Section_commands.html">4. Commands</a></li>
<li class="toctree-l1"><a class="reference internal" href="Section_gran_models.html">5. Contact models</a></li>
<li class="toctree-l1"><a class="reference internal" href="Section_mesh_modules.html">6. Mesh modules</a></li>
<li class="toctree-l1"><a class="reference internal" href="Section_packages.html">7. Packages</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="">8. How-to discussions</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#restarting-a-simulation">8.1. Restarting a simulation</a></li>
<li class="toctree-l2"><a class="reference internal" href="#d-simulations">8.2. 2d simulations</a></li>
<li class="toctree-l2"><a class="reference internal" href="#running-multiple-simulations-from-one-input-script">8.3. Running multiple simulations from one input script</a></li>
<li class="toctree-l2"><a class="reference internal" href="#granular-models">8.4. Granular models</a></li>
<li class="toctree-l2"><a class="reference internal" href="#coupling-liggghts-r-public-to-other-codes">8.5. Coupling LIGGGHTS(R)-PUBLIC to other codes</a></li>
<li class="toctree-l2"><a class="reference internal" href="#visualizing-liggghts-r-public-snapshots">8.6. Visualizing LIGGGHTS(R)-PUBLIC snapshots</a></li>
<li class="toctree-l2"><a class="reference internal" href="#triclinic-non-orthogonal-simulation-boxes">8.7. Triclinic (non-orthogonal) simulation boxes</a></li>
<li class="toctree-l2"><a class="reference internal" href="#output-from-liggghts-r-public-thermo-dumps-computes-fixes-variables">8.8. Output from LIGGGHTS(R)-PUBLIC (thermo, dumps, computes, fixes, variables)</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#global-per-atom-local-data">8.8.1. Global/per-atom/local data</a></li>
<li class="toctree-l3"><a class="reference internal" href="#scalar-vector-array-data">8.8.2. Scalar/vector/array data</a></li>
<li class="toctree-l3"><a class="reference internal" href="#thermodynamic-output">8.8.3. Thermodynamic output</a></li>
<li class="toctree-l3"><a class="reference internal" href="#dump-file-output">8.8.4. Dump file output</a></li>
<li class="toctree-l3"><a class="reference internal" href="#fixes-that-write-output-files">8.8.5. Fixes that write output files</a></li>
<li class="toctree-l3"><a class="reference internal" href="#computes-that-process-output-quantities">8.8.6. Computes that process output quantities</a></li>
<li class="toctree-l3"><a class="reference internal" href="#fixes-that-process-output-quantities">8.8.7. Fixes that process output quantities</a></li>
<li class="toctree-l3"><a class="reference internal" href="#computes-that-generate-values-to-output">8.8.8. Computes that generate values to output</a></li>
<li class="toctree-l3"><a class="reference internal" href="#fixes-that-generate-values-to-output">8.8.9. Fixes that generate values to output</a></li>
<li class="toctree-l3"><a class="reference internal" href="#variables-that-generate-values-to-output">8.8.10. Variables that generate values to output</a></li>
<li class="toctree-l3"><a class="reference internal" href="#summary-table-of-output-options-and-data-flow-between-commands">8.8.11. Summary table of output options and data flow between commands</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="#walls">8.9. Walls</a></li>
<li class="toctree-l2"><a class="reference internal" href="#library-interface-to-liggghts-r-public">8.10. Library interface to LIGGGHTS(R)-PUBLIC</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="Section_modify.html">9. Modifying &amp; extending LIGGGHTS(R)-PUBLIC</a></li>
<li class="toctree-l1"><a class="reference internal" href="Section_python.html">10. Python interface to LIGGGHTS(R)-PUBLIC</a></li>
<li class="toctree-l1"><a class="reference internal" href="Section_errors.html">11. Errors</a></li>
</ul>

            
          
        </div>
      </div>
    </nav>

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
        
          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
          <a href="Manual.html">LIGGGHTS</a>
        
      </nav>


      
      <div class="wy-nav-content">
        <div class="rst-content">
          















<div role="navigation" aria-label="breadcrumbs navigation">

  <ul class="wy-breadcrumbs">
    
      <li><a href="Manual.html">Docs</a> &raquo;</li>
        
      <li>8. How-to discussions</li>
    
    
      <li class="wy-breadcrumbs-aside">
        
            
            <a href="_sources/Section_howto.txt" rel="nofollow"> View page source</a>
          
          <a href="http://www.cfdem.com"> Website</a>
          
            <a href="Section_commands.html#comm" rel="nofollow"> Commands</a>
            
          
        
      </li>
    
  </ul>

  
  <hr/>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="Section_modify.html" class="btn btn-neutral float-right" title="9. Modifying &amp; extending LIGGGHTS(R)-PUBLIC" accesskey="n">Next <span class="fa fa-arrow-circle-right"></span></a>
      
      
        <a href="Section_packages.html" class="btn btn-neutral" title="7. Packages" accesskey="p"><span class="fa fa-arrow-circle-left"></span> Previous</a>
      
    </div>
  
</div>
          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
           <div itemprop="articleBody">
            
  <div class="section" id="how-to-discussions">
<h1>8. How-to discussions<a class="headerlink" href="#how-to-discussions" title="Permalink to this headline">¶</a></h1>
<p>This section describes how to perform common tasks using LIGGGHTS(R)-PUBLIC.</p>
<div class="contents local topic" id="contents">
<ul class="simple">
<li><a class="reference internal" href="#restarting-a-simulation" id="id62">Restarting a simulation</a></li>
<li><a class="reference internal" href="#d-simulations" id="id63">2d simulations</a></li>
<li><a class="reference internal" href="#running-multiple-simulations-from-one-input-script" id="id64">Running multiple simulations from one input script</a></li>
<li><a class="reference internal" href="#granular-models" id="id65">Granular models</a></li>
<li><a class="reference internal" href="#coupling-liggghts-r-public-to-other-codes" id="id66">Coupling LIGGGHTS(R)-PUBLIC to other codes</a></li>
<li><a class="reference internal" href="#visualizing-liggghts-r-public-snapshots" id="id67">Visualizing LIGGGHTS(R)-PUBLIC snapshots</a></li>
<li><a class="reference internal" href="#triclinic-non-orthogonal-simulation-boxes" id="id68">Triclinic (non-orthogonal) simulation boxes</a></li>
<li><a class="reference internal" href="#output-from-liggghts-r-public-thermo-dumps-computes-fixes-variables" id="id69">Output from LIGGGHTS(R)-PUBLIC (thermo, dumps, computes, fixes, variables)</a></li>
<li><a class="reference internal" href="#walls" id="id70">Walls</a></li>
<li><a class="reference internal" href="#library-interface-to-liggghts-r-public" id="id71">Library interface to LIGGGHTS(R)-PUBLIC</a></li>
</ul>
</div>
<p>The example input scripts included in the LIGGGHTS(R)-PUBLIC distribution and
highlighted in <code class="xref doc docutils literal"><span class="pre">Section_example</span></code> also show how to
setup and run various kinds of simulations.</p>
<div class="section" id="restarting-a-simulation">
<span id="howto-1"></span><h2><a class="toc-backref" href="#id62">8.1. Restarting a simulation</a><a class="headerlink" href="#restarting-a-simulation" title="Permalink to this headline">¶</a></h2>
<p>There are 3 ways to continue a long LIGGGHTS(R)-PUBLIC simulation.  Multiple
<a class="reference internal" href="run.html"><em>run</em></a> commands can be used in the same input script.  Each
run will continue from where the previous run left off.  Or binary
restart files can be saved to disk using the <a class="reference internal" href="restart.html"><em>restart</em></a>
command.  At a later time, these binary files can be read via a
<a class="reference internal" href="read_restart.html"><em>read_restart</em></a> command in a new script.  Or they can
be converted to text data files using the <a class="reference internal" href="Section_start.html#start-7"><span>-r command-line switch</span></a> and read by a
<a class="reference internal" href="read_data.html"><em>read_data</em></a> command in a new script.</p>
<p>The <a class="reference internal" href="read_restart.html"><em>read_restart</em></a> command typically replaces
the &#8220;create_box&#8221;create_box.html command in the input script that restarts
the simulation.</p>
<p>Note that while the internal state of the simulation is stored in the
restart file, most material properties and simulation settings are
not stored in the restart file. Be careful when changing settings and/or
material parameters when restarting a simulation.</p>
<p>The following commands do not need to be repeated because
their settings are included in the restart file: <em>units, atom_style</em>.</p>
<p>As an alternate approach, the restart file could be converted to a data
file as follows:</p>
<div class="highlight-python"><div class="highlight"><pre>lmp_g++ -r tmp.restart.50 tmp.restart.data
</pre></div>
</div>
<p>Then, the &#8220;read_data&#8221;read_data.html command can be used to restart the
simulation.</p>
<p><a class="reference internal" href="reset_timestep.html"><em>reset_timestep</em></a> command can be used to tell
LIGGGHTS(R)-PUBLIC the current timestep.</p>
<hr class="docutils" />
</div>
<div class="section" id="d-simulations">
<span id="howto-2"></span><h2><a class="toc-backref" href="#id63">8.2. 2d simulations</a><a class="headerlink" href="#d-simulations" title="Permalink to this headline">¶</a></h2>
<p>Use the <a class="reference internal" href="dimension.html"><em>dimension</em></a> command to specify a 2d simulation.</p>
<p>Make the simulation box periodic in z via the <a class="reference internal" href="boundary.html"><em>boundary</em></a>
command.  This is the default.</p>
<p>If using the <a class="reference internal" href="create_box.html"><em>create box</em></a> command to define a
simulation box, set the z dimensions narrow, but finite, so that the
create_atoms command will tile the 3d simulation box with a single z
plane of atoms - e.g.</p>
<pre class="literal-block">
<a class="reference internal" href="create_box.html"><em>create box</em></a> 1 -10 10 -10 10 -0.25 0.25
</pre>
<p>If using the <a class="reference internal" href="read_data.html"><em>read data</em></a> command to read in a file of
atom coordinates, set the &#8220;zlo zhi&#8221; values to be finite but narrow,
similar to the create_box command settings just described.  For each
atom in the file, assign a z coordinate so it falls inside the
z-boundaries of the box - e.g. 0.0.</p>
<p>Use the <a class="reference internal" href="fix_enforce2d.html"><em>fix enforce2d</em></a> command as the last
defined fix to insure that the z-components of velocities and forces
are zeroed out every timestep.  The reason to make it the last fix is
so that any forces induced by other fixes will be zeroed out.</p>
<p>Many of the example input scripts included in the LIGGGHTS(R)-PUBLIC distribution
are for 2d models.</p>
<div class="admonition warning">
<p class="first admonition-title">Warning</p>
<p class="last">Some models in LIGGGHTS(R)-PUBLIC treat particles as finite-size
spheres, as opposed to point particles.  In 2d, the particles will
still be spheres, not disks, meaning their moment of inertia will be
the same as in 3d.</p>
</div>
<hr class="docutils" />
</div>
<div class="section" id="running-multiple-simulations-from-one-input-script">
<span id="howto-3"></span><h2><a class="toc-backref" href="#id64">8.3. Running multiple simulations from one input script</a><a class="headerlink" href="#running-multiple-simulations-from-one-input-script" title="Permalink to this headline">¶</a></h2>
<p>This can be done in several ways.  See the documentation for
individual commands for more details on how these examples work.</p>
<p>If &#8220;multiple simulations&#8221; means continue a previous simulation for
more timesteps, then you simply use the <a class="reference internal" href="run.html"><em>run</em></a> command
multiple times.  For example, this script</p>
<div class="highlight-python"><div class="highlight"><pre>units lj
atom_style atomic
read_data data.lj
run 10000
run 10000
run 10000
run 10000
run 10000
</pre></div>
</div>
<p>would run 5 successive simulations of the same system for a total of
50,000 timesteps.</p>
<p>If you wish to run totally different simulations, one after the other,
the <a class="reference internal" href="clear.html"><em>clear</em></a> command can be used in between them to
re-initialize LIGGGHTS(R)-PUBLIC.  For example, this script</p>
<div class="highlight-python"><div class="highlight"><pre>units lj
atom_style atomic
read_data data.lj
run 10000
clear
units lj
atom_style atomic
read_data data.lj.new
run 10000
</pre></div>
</div>
<p>would run 2 independent simulations, one after the other.</p>
<p>For large numbers of independent simulations, you can use
<a class="reference internal" href="variable.html"><em>variables</em></a> and the <a class="reference internal" href="next.html"><em>next</em></a> and
<a class="reference internal" href="jump.html"><em>jump</em></a> commands to loop over the same input script
multiple times with different settings.  For example, this
script, named in.polymer</p>
<div class="highlight-python"><div class="highlight"><pre>variable d index run1 run2 run3 run4 run5 run6 run7 run8
shell cd $d
read_data data.polymer
run 10000
shell cd ..
clear
next d
jump in.polymer
</pre></div>
</div>
<p>would run 8 simulations in different directories, using a data.polymer
file in each directory.  The same concept could be used to run the
same system at 8 different temperatures, using a temperature variable
and storing the output in different log and dump files, for example</p>
<div class="highlight-python"><div class="highlight"><pre>variable a loop 8
variable t index 0.8 0.85 0.9 0.95 1.0 1.05 1.1 1.15
log log.$a
read data.polymer
velocity all create $t 352839
fix 1 all nvt $t $t 100.0
dump 1 all atom 1000 dump.$a
run 100000
next t
next a
jump in.polymer
</pre></div>
</div>
<p>All of the above examples work whether you are running on 1 or
multiple processors, but assumed you are running LIGGGHTS(R)-PUBLIC on a single
partition of processors.  LIGGGHTS(R)-PUBLIC can be run on multiple partitions via
the &#8220;-partition&#8221; command-line switch as described in <a class="reference internal" href="Section_start.html#start-7"><span>this section</span></a> of the manual.</p>
<p>In the last 2 examples, if LIGGGHTS(R)-PUBLIC were run on 3 partitions, the same
scripts could be used if the &#8220;index&#8221; and &#8220;loop&#8221; variables were
replaced with <em>universe</em>-style variables, as described in the
<a class="reference internal" href="variable.html"><em>variable</em></a> command.  Also, the &#8220;next t&#8221; and &#8220;next a&#8221;
commands would need to be replaced with a single &#8220;next a t&#8221; command.
With these modifications, the 8 simulations of each script would run
on the 3 partitions one after the other until all were finished.
Initially, 3 simulations would be started simultaneously, one on each
partition.  When one finished, that partition would then start
the 4th simulation, and so forth, until all 8 were completed.</p>
<hr class="docutils" />
</div>
<div class="section" id="granular-models">
<span id="howto-4"></span><h2><a class="toc-backref" href="#id65">8.4. Granular models</a><a class="headerlink" href="#granular-models" title="Permalink to this headline">¶</a></h2>
<p>Granular system are composed of spherical particles with a diameter,
as opposed to point particles.  This means they have an angular
velocity and torque can be imparted to them to cause them to rotate.</p>
<p>To run a simulation of a granular model, you will want to use
the following commands:</p>
<ul class="simple">
<li><a class="reference internal" href="atom_style.html"><em>atom_style sphere</em></a></li>
<li><a class="reference internal" href="fix_nve_sphere.html"><em>fix nve/sphere</em></a></li>
<li><a class="reference internal" href="fix_gravity.html"><em>fix gravity</em></a></li>
</ul>
<p>This compute</p>
<ul class="simple">
<li><a class="reference internal" href="compute_erotate_sphere.html"><em>compute erotate/sphere</em></a></li>
</ul>
<p>calculates rotational kinetic energy which can be <a class="reference internal" href="#howto-8"><span>output with thermodynamic info</span></a>.</p>
<p>Use a number of particle-particle and particle-wall contact models,
which compute forces and torques between interacting pairs of particles
and between particles and primitive walls or mesh elements. Details
can be found here:</p>
<ul class="simple">
<li><a class="reference internal" href="pair_gran.html"><em>pair_style gran</em></a></li>
<li><a class="reference internal" href="Section_gran_models.html"><em>List of all contact models</em></a></li>
</ul>
<p>These commands implement fix options specific to granular systems:</p>
<ul class="simple">
<li><a class="reference internal" href="fix_freeze.html"><em>fix freeze</em></a></li>
<li><code class="xref doc docutils literal"><span class="pre">fix</span> <span class="pre">pour</span></code></li>
<li><a class="reference internal" href="fix_viscous.html"><em>fix viscous</em></a></li>
<li><a class="reference internal" href="fix_wall_gran.html"><em>fix wall/gran</em></a></li>
</ul>
<p><a class="reference internal" href="fix_wall_gran.html"><em>fix wall/gran</em></a> commands can define two types of
walls: primitive and mesh. Mesh walls are defined using a
<a class="reference internal" href="fix_mesh_surface.html"><em>fix mesh/surface</em></a> or related command.</p>
<p>The fix style <em>freeze</em> zeroes both the force and torque of frozen
atoms, and should be used for granular system instead of the fix style
<em>setforce</em>.</p>
<p>For computational efficiency, you can eliminate needless pairwise
computations between frozen atoms by using this command:</p>
<ul class="simple">
<li><a class="reference internal" href="neigh_modify.html"><em>neigh_modify</em></a> exclude</li>
</ul>
<hr class="docutils" />
</div>
<div class="section" id="coupling-liggghts-r-public-to-other-codes">
<span id="howto-5"></span><h2><a class="toc-backref" href="#id66">8.5. Coupling LIGGGHTS(R)-PUBLIC to other codes</a><a class="headerlink" href="#coupling-liggghts-r-public-to-other-codes" title="Permalink to this headline">¶</a></h2>
<p>LIGGGHTS(R)-PUBLIC is designed to allow it to be coupled to other codes.  For
example, a quantum mechanics code might compute forces on a subset of
atoms and pass those forces to LIGGGHTS(R)-PUBLIC.  Or a continuum finite element
(FE) simulation might use atom positions as boundary conditions on FE
nodal points, compute a FE solution, and return interpolated forces on
MD atoms.</p>
<p>LIGGGHTS(R)-PUBLIC can be coupled to other codes in at least 3 ways.  Each has
advantages and disadvantages, which you&#8217;ll have to think about in the
context of your application.</p>
<p>(1) Define a new <a class="reference internal" href="fix.html"><em>fix</em></a> command that calls the other code.  In
this scenario, LIGGGHTS(R)-PUBLIC is the driver code.  During its timestepping,
the fix is invoked, and can make library calls to the other code,
which has been linked to LIGGGHTS(R)-PUBLIC as a library.  This is the way the
<a class="reference external" href="http://www.rpi.edu/~anderk5/lab">POEMS</a> package that performs constrained rigid-body motion on
groups of atoms is hooked to LIGGGHTS(R)-PUBLIC.  See the
<a class="reference internal" href="fix_poems.html"><em>fix_poems</em></a> command for more details.  See <a class="reference internal" href="Section_modify.html"><em>this section</em></a> of the documentation for info on how to add
a new fix to LIGGGHTS(R)-PUBLIC.</p>
<p>(2) Define a new LIGGGHTS(R)-PUBLIC command that calls the other code.  This is
conceptually similar to method (1), but in this case LIGGGHTS(R)-PUBLIC and the
other code are on a more equal footing.  Note that now the other code
is not called during the timestepping of a LIGGGHTS(R)-PUBLIC run, but between
runs.  The LIGGGHTS(R)-PUBLIC input script can be used to alternate LIGGGHTS(R)-PUBLIC runs
with calls to the other code, invoked via the new command.  The
<a class="reference internal" href="run.html"><em>run</em></a> command facilitates this with its <em>every</em> option, which
makes it easy to run a few steps, invoke the command, run a few steps,
invoke the command, etc.</p>
<p>In this scenario, the other code can be called as a library, as in
(1), or it could be a stand-alone code, invoked by a system() call
made by the command (assuming your parallel machine allows one or more
processors to start up another program).  In the latter case the
stand-alone code could communicate with LIGGGHTS(R)-PUBLIC thru files that the
command writes and reads.</p>
<p>See <a class="reference internal" href="Section_modify.html"><em>Section_modify</em></a> of the documentation for how
to add a new command to LIGGGHTS(R)-PUBLIC.</p>
<p>(3) Use LIGGGHTS(R)-PUBLIC as a library called by another code.  In this case the
other code is the driver and calls LIGGGHTS(R)-PUBLIC as needed.  Or a wrapper
code could link and call both LIGGGHTS(R)-PUBLIC and another code as libraries.
Again, the <a class="reference internal" href="run.html"><em>run</em></a> command has options that allow it to be
invoked with minimal overhead (no setup or clean-up) if you wish to do
multiple short runs, driven by another program.</p>
<p>Examples of driver codes that call LIGGGHTS(R)-PUBLIC as a library are included in
the examples/COUPLE directory of the LIGGGHTS(R)-PUBLIC distribution; see
examples/COUPLE/README for more details:</p>
<ul class="simple">
<li>simple: simple driver programs in C++ and C which invoke LIGGGHTS(R)-PUBLIC as a
library</li>
<li>lammps_quest: coupling of LIGGGHTS(R)-PUBLIC and <a class="reference external" href="http://dft.sandia.gov/Quest">Quest</a>, to run classical
MD with quantum forces calculated by a density functional code</li>
<li>lammps_spparks: coupling of LIGGGHTS(R)-PUBLIC and <a class="reference external" href="http://www.sandia.gov/~sjplimp/spparks.html">SPPARKS</a>, to couple
a kinetic Monte Carlo model for grain growth using MD to calculate
strain induced across grain boundaries</li>
</ul>
<p><a class="reference internal" href="Section_start.html#start-5"><span>This section</span></a> of the documentation
describes how to build LIGGGHTS(R)-PUBLIC as a library.  Once this is done, you
can interface with LIGGGHTS(R)-PUBLIC either via C++, C, Fortran, or Python (or
any other language that supports a vanilla C-like interface).  For
example, from C++ you could create one (or more) &#8220;instances&#8221; of
LIGGGHTS(R)-PUBLIC, pass it an input script to process, or execute individual
commands, all by invoking the correct class methods in LIGGGHTS(R)-PUBLIC.  From C
or Fortran you can make function calls to do the same things.  See
<a class="reference internal" href="Section_python.html"><em>Section_python</em></a> of the manual for a description
of the Python wrapper provided with LIGGGHTS(R)-PUBLIC that operates through the
LIGGGHTS(R)-PUBLIC library interface.</p>
<p>The files src/library.cpp and library.h contain the C-style interface
to LIGGGHTS(R)-PUBLIC.  See <span class="xref std std-ref">Section_howto 19</span> of the
manual for a description of the interface and how to extend it for
your needs.</p>
<p>Note that the lammps_open() function that creates an instance of
LIGGGHTS(R)-PUBLIC takes an MPI communicator as an argument.  This means that
instance of LIGGGHTS(R)-PUBLIC will run on the set of processors in the
communicator.  Thus the calling code can run LIGGGHTS(R)-PUBLIC on all or a subset
of processors.  For example, a wrapper script might decide to
alternate between LIGGGHTS(R)-PUBLIC and another code, allowing them both to run
on all the processors.  Or it might allocate half the processors to
LIGGGHTS(R)-PUBLIC and half to the other code and run both codes simultaneously
before syncing them up periodically.  Or it might instantiate multiple
instances of LIGGGHTS(R)-PUBLIC to perform different calculations.</p>
<hr class="docutils" />
</div>
<div class="section" id="visualizing-liggghts-r-public-snapshots">
<span id="howto-6"></span><h2><a class="toc-backref" href="#id67">8.6. Visualizing LIGGGHTS(R)-PUBLIC snapshots</a><a class="headerlink" href="#visualizing-liggghts-r-public-snapshots" title="Permalink to this headline">¶</a></h2>
<p>LIGGGHTS(R)-PUBLIC itself does not do visualization, but snapshots from LIGGGHTS(R)-PUBLIC
simulations can be visualized (and analyzed) in a variety of ways.</p>
<p>LIGGGHTS(R)-PUBLIC snapshots are created by the <a class="reference internal" href="dump.html"><em>dump</em></a> command which can
create files in several formats.  The native LIGGGHTS(R)-PUBLIC dump format is a
text file (see &#8220;dump atom&#8221; or &#8220;dump custom&#8221;).</p>
<p>A Python-based toolkit (LPP) distributed by our group can read native LIGGGHTS(R)-PUBLIC
dump files, including custom dump files with additional columns of
user-specified atom information, and convert them to VTK file formats
that can be read with Paraview.</p>
<p>Also, there exist a number of <a class="reference internal" href="dump.html"><em>dump</em></a> commands that output to
VTK natively.</p>
<hr class="docutils" />
</div>
<div class="section" id="triclinic-non-orthogonal-simulation-boxes">
<span id="howto-7"></span><h2><a class="toc-backref" href="#id68">8.7. Triclinic (non-orthogonal) simulation boxes</a><a class="headerlink" href="#triclinic-non-orthogonal-simulation-boxes" title="Permalink to this headline">¶</a></h2>
<p>By default, LIGGGHTS(R)-PUBLIC uses an orthogonal simulation box to encompass the
particles.  The <a class="reference internal" href="boundary.html"><em>boundary</em></a> command sets the boundary
conditions of the box (periodic, non-periodic, etc).  The orthogonal
box has its &#8220;origin&#8221; at (xlo,ylo,zlo) and is defined by 3 edge vectors
starting from the origin given by <strong>a</strong> = (xhi-xlo,0,0); <strong>b</strong> =
(0,yhi-ylo,0); <strong>c</strong> = (0,0,zhi-zlo).  The 6 parameters
(xlo,xhi,ylo,yhi,zlo,zhi) are defined at the time the simulation box
is created, e.g. by the <a class="reference internal" href="create_box.html"><em>create_box</em></a> or
<a class="reference internal" href="read_data.html"><em>read_data</em></a> or <a class="reference internal" href="read_restart.html"><em>read_restart</em></a>
commands.  Additionally, LIGGGHTS(R)-PUBLIC defines box size parameters lx,ly,lz
where lx = xhi-xlo, and similarly in the y and z dimensions.  The 6
parameters, as well as lx,ly,lz, can be output via the <a class="reference internal" href="thermo_style.html"><em>thermo_style custom</em></a> command.</p>
<p>LIGGGHTS(R)-PUBLIC also allows simulations to be performed in triclinic
(non-orthogonal) simulation boxes shaped as a parallelepiped with
triclinic symmetry.  The parallelepiped has its &#8220;origin&#8221; at
(xlo,ylo,zlo) and is defined by 3 edge vectors starting from the
origin given by <strong>a</strong> = (xhi-xlo,0,0); <strong>b</strong> = (xy,yhi-ylo,0); <strong>c</strong> =
(xz,yz,zhi-zlo).  <em>xy,xz,yz</em> can be 0.0 or positive or negative values
and are called &#8220;tilt factors&#8221; because they are the amount of
displacement applied to faces of an originally orthogonal box to
transform it into the parallelepiped.  In LIGGGHTS(R)-PUBLIC the triclinic
simulation box edge vectors <strong>a</strong>, <strong>b</strong>, and <strong>c</strong> cannot be arbitrary
vectors.  As indicated, <strong>a</strong> must lie on the positive x axis.  <strong>b</strong> must
lie in the xy plane, with strictly positive y component. <strong>c</strong> may have
any orientation with strictly positive z component.  The requirement
that <strong>a</strong>, <strong>b</strong>, and <strong>c</strong> have strictly positive x, y, and z components,
respectively, ensures that <strong>a</strong>, <strong>b</strong>, and <strong>c</strong> form a complete
right-handed basis.  These restrictions impose no loss of generality,
since it is possible to rotate/invert any set of 3 crystal basis
vectors so that they conform to the restrictions.</p>
<p>For example, assume that the 3 vectors <strong>A</strong>,**B**,**C** are the edge
vectors of a general parallelepiped, where there is no restriction on
<strong>A</strong>,**B**,**C** other than they form a complete right-handed basis i.e.
<strong>A</strong> x <strong>B</strong> . <strong>C</strong> &gt; 0.  The equivalent LIGGGHTS(R)-PUBLIC <strong>a</strong>,**b**,**c** are a linear
rotation of <strong>A</strong>, <strong>B</strong>, and <strong>C</strong> and can be computed as follows:</p>
<img alt="_images/transform.jpg" class="align-center" src="_images/transform.jpg" />
<p>where A = <a href="#id60"><span class="problematic" id="id61">|**A**|</span></a> indicates the scalar length of <strong>A</strong>. The ^ hat symbol
indicates the corresponding unit vector. <em>beta</em> and <em>gamma</em> are angles
between the vectors described below. Note that by construction,
<strong>a</strong>, <strong>b</strong>, and <strong>c</strong> have strictly positive x, y, and z components, respectively.
If it should happen that
<strong>A</strong>, <strong>B</strong>, and <strong>C</strong> form a left-handed basis, then the above equations
are not valid for <strong>c</strong>. In this case, it is necessary
to first apply an inversion. This can be achieved
by interchanging two basis vectors or by changing the sign of one of them.</p>
<p>For consistency, the same rotation/inversion applied to the basis vectors
must also be applied to atom positions, velocities,
and any other vector quantities.
This can be conveniently achieved by first converting to
fractional coordinates in the
old basis and then converting to distance coordinates in the new basis.
The transformation is given by the following equation:</p>
<img alt="_images/rotate.jpg" class="align-center" src="_images/rotate.jpg" />
<p>where <em>V</em> is the volume of the box, <strong>X</strong> is the original vector quantity and
<strong>x</strong> is the vector in the LIGGGHTS(R)-PUBLIC basis.</p>
<p>There is no requirement that a triclinic box be periodic in any
dimension, though it typically should be in at least the 2nd dimension
of the tilt (y in xy) if you want to enforce a shift in periodic
boundary conditions across that boundary.  Some commands that work
with triclinic boxes, e.g. the <a class="reference internal" href="fix_deform.html"><em>fix deform</em></a> and <code class="xref doc docutils literal"><span class="pre">fix</span> <span class="pre">npt</span></code> commands, require periodicity or non-shrink-wrap
boundary conditions in specific dimensions.  See the command doc pages
for details.</p>
<p>The 9 parameters (xlo,xhi,ylo,yhi,zlo,zhi,xy,xz,yz) are defined at the
time the simluation box is created.  This happens in one of 3 ways.
If the <a class="reference internal" href="create_box.html"><em>create_box</em></a> command is used with a region of
style <em>prism</em>, then a triclinic box is setup.  See the
<a class="reference internal" href="region.html"><em>region</em></a> command for details.  If the
<a class="reference internal" href="read_data.html"><em>read_data</em></a> command is used to define the simulation
box, and the header of the data file contains a line with the &#8220;xy xz
yz&#8221; keyword, then a triclinic box is setup.  See the
<a class="reference internal" href="read_data.html"><em>read_data</em></a> command for details.  Finally, if the
<a class="reference internal" href="read_restart.html"><em>read_restart</em></a> command reads a restart file which
was written from a simulation using a triclinic box, then a triclinic
box will be setup for the restarted simulation.</p>
<p>Note that you can define a triclinic box with all 3 tilt factors =
0.0, so that it is initially orthogonal.  This is necessary if the box
will become non-orthogonal, e.g. due to the <code class="xref doc docutils literal"><span class="pre">fix</span> <span class="pre">npt</span></code> or
<a class="reference internal" href="fix_deform.html"><em>fix deform</em></a> commands.  Alternatively, you can use the
<a class="reference internal" href="change_box.html"><em>change_box</em></a> command to convert a simulation box from
orthogonal to triclinic and vice versa.</p>
<p>As with orthogonal boxes, LIGGGHTS(R)-PUBLIC defines triclinic box size parameters
lx,ly,lz where lx = xhi-xlo, and similarly in the y and z dimensions.
The 9 parameters, as well as lx,ly,lz, can be output via the
<a class="reference internal" href="thermo_style.html"><em>thermo_style custom</em></a> command.</p>
<p>To avoid extremely tilted boxes (which would be computationally
inefficient), LIGGGHTS(R)-PUBLIC normally requires that no tilt factor can skew
the box more than half the distance of the parallel box length, which
is the 1st dimension in the tilt factor (x for xz).  This is required
both when the simulation box is created, e.g. via the
<a class="reference internal" href="create_box.html"><em>create_box</em></a> or <a class="reference internal" href="read_data.html"><em>read_data</em></a> commands,
as well as when the box shape changes dynamically during a simulation,
e.g. via the <a class="reference internal" href="fix_deform.html"><em>fix deform</em></a> command.</p>
<p>For example, if xlo = 2 and xhi = 12, then the x box length is 10 and
the xy tilt factor must be between -5 and 5.  Similarly, both xz and
yz must be between -(xhi-xlo)/2 and +(yhi-ylo)/2.  Note that this is
not a limitation, since if the maximum tilt factor is 5 (as in this
example), then configurations with tilt = ..., -15, -5, 5, 15, 25,
... are geometrically all equivalent.  If the box tilt exceeds this
limit during a dynamics run (e.g. via the <a class="reference internal" href="fix_deform.html"><em>fix deform</em></a>
command), then the box is &#8220;flipped&#8221; to an equivalent shape with a tilt
factor within the bounds, so the run can continue.  See the <a class="reference internal" href="fix_deform.html"><em>fix deform</em></a> doc page for further details.</p>
<p>One exception to this rule is if the 1st dimension in the tilt
factor (x for xy) is non-periodic.  In that case, the limits on the
tilt factor are not enforced, since flipping the box in that dimension
does not change the atom positions due to non-periodicity.  In this
mode, if you tilt the system to extreme angles, the simulation will
simply become inefficient, due to the highly skewed simulation box.</p>
<p>The limitation on not creating a simulation box with a tilt factor
skewing the box more than half the distance of the parallel box length
can be overridden via the <a class="reference internal" href="box.html"><em>box</em></a> command.  Setting the <em>tilt</em>
keyword to <em>large</em> allows any tilt factors to be specified.</p>
<p>Note that if a simulation box has a large tilt factor, LIGGGHTS(R)-PUBLIC will run
less efficiently, due to the large volume of communication needed to
acquire ghost atoms around a processor&#8217;s irregular-shaped sub-domain.
For extreme values of tilt, LIGGGHTS(R)-PUBLIC may also lose atoms and generate an
error.</p>
<p>Triclinic crystal structures are often defined using three lattice
constants <em>a</em>, <em>b</em>, and <em>c</em>, and three angles <em>alpha</em>, <em>beta</em> and
<em>gamma</em>. Note that in this nomenclature, the a, b, and c lattice
constants are the scalar lengths of the edge vectors <strong>a</strong>, <strong>b</strong>, and <strong>c</strong>
defined above.  The relationship between these 6 quantities
(a,b,c,alpha,beta,gamma) and the LIGGGHTS(R)-PUBLIC box sizes (lx,ly,lz) =
(xhi-xlo,yhi-ylo,zhi-zlo) and tilt factors (xy,xz,yz) is as follows:</p>
<img alt="_images/box.jpg" class="align-center" src="_images/box.jpg" />
<p>The inverse relationship can be written as follows:</p>
<img alt="_images/box_inverse.jpg" class="align-center" src="_images/box_inverse.jpg" />
<p>The values of <em>a</em>, <em>b</em>, <em>c</em> , <em>alpha</em>, <em>beta</em> , and <em>gamma</em> can be printed
out or accessed by computes using the
<a class="reference internal" href="thermo_style.html"><em>thermo_style custom</em></a> keywords
<em>cella</em>, <em>cellb</em>, <em>cellc</em>, <em>cellalpha</em>, <em>cellbeta</em>, <em>cellgamma</em>,
respectively.</p>
<p>As discussed on the <a class="reference internal" href="dump.html"><em>dump</em></a> command doc page, when the BOX
BOUNDS for a snapshot is written to a dump file for a triclinic box,
an orthogonal bounding box which encloses the triclinic simulation box
is output, along with the 3 tilt factors (xy, xz, yz) of the triclinic
box, formatted as follows:</p>
<div class="highlight-python"><div class="highlight"><pre>ITEM: BOX BOUNDS xy xz yz
xlo_bound xhi_bound xy
ylo_bound yhi_bound xz
zlo_bound zhi_bound yz
</pre></div>
</div>
<p>This bounding box is convenient for many visualization programs and is
calculated from the 9 triclinic box parameters
(xlo,xhi,ylo,yhi,zlo,zhi,xy,xz,yz) as follows:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">xlo_bound</span> <span class="o">=</span> <span class="n">xlo</span> <span class="o">+</span> <span class="n">MIN</span><span class="p">(</span><span class="mf">0.0</span><span class="p">,</span><span class="n">xy</span><span class="p">,</span><span class="n">xz</span><span class="p">,</span><span class="n">xy</span><span class="o">+</span><span class="n">xz</span><span class="p">)</span>
<span class="n">xhi_bound</span> <span class="o">=</span> <span class="n">xhi</span> <span class="o">+</span> <span class="n">MAX</span><span class="p">(</span><span class="mf">0.0</span><span class="p">,</span><span class="n">xy</span><span class="p">,</span><span class="n">xz</span><span class="p">,</span><span class="n">xy</span><span class="o">+</span><span class="n">xz</span><span class="p">)</span>
<span class="n">ylo_bound</span> <span class="o">=</span> <span class="n">ylo</span> <span class="o">+</span> <span class="n">MIN</span><span class="p">(</span><span class="mf">0.0</span><span class="p">,</span><span class="n">yz</span><span class="p">)</span>
<span class="n">yhi_bound</span> <span class="o">=</span> <span class="n">yhi</span> <span class="o">+</span> <span class="n">MAX</span><span class="p">(</span><span class="mf">0.0</span><span class="p">,</span><span class="n">yz</span><span class="p">)</span>
<span class="n">zlo_bound</span> <span class="o">=</span> <span class="n">zlo</span>
<span class="n">zhi_bound</span> <span class="o">=</span> <span class="n">zhi</span>
</pre></div>
</div>
<p>These formulas can be inverted if you need to convert the bounding box
back into the triclinic box parameters, e.g. xlo = xlo_bound -
MIN(0.0,xy,xz,xy+xz).</p>
<hr class="docutils" />
</div>
<div class="section" id="output-from-liggghts-r-public-thermo-dumps-computes-fixes-variables">
<span id="howto-8"></span><h2><a class="toc-backref" href="#id69">8.8. Output from LIGGGHTS(R)-PUBLIC (thermo, dumps, computes, fixes, variables)</a><a class="headerlink" href="#output-from-liggghts-r-public-thermo-dumps-computes-fixes-variables" title="Permalink to this headline">¶</a></h2>
<p>There are four basic kinds of LIGGGHTS(R)-PUBLIC output:</p>
<ul class="simple">
<li><a class="reference internal" href="thermo_style.html"><em>Thermodynamic output</em></a>, which is a list
of quantities printed every few timesteps to the screen and logfile.</li>
<li><a class="reference internal" href="dump.html"><em>Dump files</em></a>, which contain snapshots of atoms and various
per-atom values and are written at a specified frequency.</li>
<li>Certain fixes can output user-specified quantities to files: <a class="reference internal" href="fix_ave_time.html"><em>fix ave/time</em></a> for time averaging, <a class="reference internal" href="fix_ave_spatial.html"><em>fix ave/spatial</em></a> for spatial averaging, and <a class="reference internal" href="fix_print.html"><em>fix print</em></a> for single-line output of
<a class="reference internal" href="variable.html"><em>variables</em></a>.  Fix print can also output to the
screen.</li>
<li><a class="reference internal" href="restart.html"><em>Restart files</em></a>.</li>
</ul>
<p>A simulation prints one set of thermodynamic output and (optionally)
restart files.  It can generate any number of dump files and fix
output files, depending on what <a class="reference internal" href="dump.html"><em>dump</em></a> and <a class="reference internal" href="fix.html"><em>fix</em></a>
commands you specify.</p>
<p>As discussed below, LIGGGHTS(R)-PUBLIC gives you a variety of ways to determine
what quantities are computed and printed when the thermodynamics,
dump, or fix commands listed above perform output.  Throughout this
discussion, note that users can also <a class="reference internal" href="Section_modify.html"><em>add their own computes and fixes to LIGGGHTS(R)-PUBLIC</em></a> which can then generate values that can
then be output with these commands.</p>
<p>The following sub-sections discuss different LIGGGHTS(R)-PUBLIC command related
to output and the kind of data they operate on and produce:</p>
<ul class="simple">
<li><a class="reference internal" href="#global"><span>Global/per-atom/local data</span></a></li>
<li><a class="reference internal" href="#scalar"><span>Scalar/vector/array data</span></a></li>
<li><a class="reference internal" href="#thermo"><span>Thermodynamic output</span></a></li>
<li><a class="reference internal" href="#dump"><span>Dump file output</span></a></li>
<li><span class="xref std std-ref">Fixes that write output files</span></li>
<li><a class="reference internal" href="#computeoutput"><span>Computes that process output quantities</span></a></li>
<li><span class="xref std std-ref">Fixes that process output quantities</span></li>
<li><a class="reference internal" href="#compute"><span>Computes that generate values to output</span></a></li>
<li><a class="reference internal" href="#fix"><span>Fixes that generate values to output</span></a></li>
<li><a class="reference internal" href="#variable"><span>Variables that generate values to output</span></a></li>
<li><a class="reference internal" href="#table"><span>Summary table of output options and data flow between commands</span></a></li>
</ul>
<div class="section" id="global-per-atom-local-data">
<span id="global"></span><h3>8.8.1. Global/per-atom/local data<a class="headerlink" href="#global-per-atom-local-data" title="Permalink to this headline">¶</a></h3>
<p>Various output-related commands work with three different styles of
data: global, per-atom, or local.  A global datum is one or more
system-wide values, e.g. the temperature of the system.  A per-atom
datum is one or more values per atom, e.g. the kinetic energy of each
atom.  Local datums are calculated by each processor based on the
atoms it owns, but there may be zero or more per atom, e.g. a list of
bond distances.</p>
</div>
<div class="section" id="scalar-vector-array-data">
<span id="scalar"></span><h3>8.8.2. Scalar/vector/array data<a class="headerlink" href="#scalar-vector-array-data" title="Permalink to this headline">¶</a></h3>
<p>Global, per-atom, and local datums can each come in three kinds: a
single scalar value, a vector of values, or a 2d array of values.  The
doc page for a &#8220;compute&#8221; or &#8220;fix&#8221; or &#8220;variable&#8221; that generates data
will specify both the style and kind of data it produces, e.g. a
per-atom vector.</p>
<p>When a quantity is accessed, as in many of the output commands
discussed below, it can be referenced via the following bracket
notation, where ID in this case is the ID of a compute.  The leading
&#8220;<a href="#id72"><span class="problematic" id="id73">c_</span></a>&#8221; would be replaced by &#8220;<a href="#id74"><span class="problematic" id="id75">f_</span></a>&#8221; for a fix, or &#8220;<a href="#id76"><span class="problematic" id="id77">v_</span></a>&#8221; for a variable:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td>c_ID</td>
<td>entire scalar, vector, or array</td>
</tr>
<tr class="row-even"><td>c_ID[I]</td>
<td>one element of vector, one column of array</td>
</tr>
<tr class="row-odd"><td>c_ID[I][J]</td>
<td>one element of array</td>
</tr>
</tbody>
</table>
<p>In other words, using one bracket reduces the dimension of the data
once (vector -&gt; scalar, array -&gt; vector).  Using two brackets reduces
the dimension twice (array -&gt; scalar).  Thus a command that uses
scalar values as input can typically also process elements of a vector
or array.</p>
</div>
<div class="section" id="thermodynamic-output">
<span id="thermo"></span><h3>8.8.3. Thermodynamic output<a class="headerlink" href="#thermodynamic-output" title="Permalink to this headline">¶</a></h3>
<p>The frequency and format of thermodynamic output is set by the
<a class="reference internal" href="thermo.html"><em>thermo</em></a>, <a class="reference internal" href="thermo_style.html"><em>thermo_style</em></a>, and
<a class="reference internal" href="thermo_modify.html"><em>thermo_modify</em></a> commands.  The
<a class="reference internal" href="thermo_style.html"><em>thermo_style</em></a> command also specifies what values
are calculated and written out.  Pre-defined keywords can be specified
(e.g. press, etotal, etc).  Three additional kinds of keywords can
also be specified (c_ID, f_ID, v_name), where a <a class="reference internal" href="compute.html"><em>compute</em></a>
or <a class="reference internal" href="fix.html"><em>fix</em></a> or <a class="reference internal" href="variable.html"><em>variable</em></a> provides the value to be
output.  In each case, the compute, fix, or variable must generate
global values for input to the <a class="reference internal" href="dump.html"><em>thermo_style custom</em></a>
command.</p>
<p>Note that thermodynamic output values can be &#8220;extensive&#8221; or
&#8220;intensive&#8221;.  The former scale with the number of atoms in the system
(e.g. total energy), the latter do not (e.g. temperature).  The
setting for <a class="reference internal" href="thermo_modify.html"><em>thermo_modify norm</em></a> determines whether
extensive quantities are normalized or not.  Computes and fixes
produce either extensive or intensive values; see their individual doc
pages for details.  <a class="reference internal" href="variable.html"><em>Equal-style variables</em></a> produce only
intensive values; you can include a division by &#8220;natoms&#8221; in the
formula if desired, to make an extensive calculation produce an
intensive result.</p>
</div>
<div class="section" id="dump-file-output">
<span id="dump"></span><h3>8.8.4. Dump file output<a class="headerlink" href="#dump-file-output" title="Permalink to this headline">¶</a></h3>
<p>Dump file output is specified by the <a class="reference internal" href="dump.html"><em>dump</em></a> and
<a class="reference internal" href="dump_modify.html"><em>dump_modify</em></a> commands.  There are several
pre-defined formats (dump atom, dump xtc, etc).</p>
<p>There is also a <a class="reference internal" href="dump.html"><em>dump custom</em></a> format where the user
specifies what values are output with each atom.  Pre-defined atom
attributes can be specified (id, x, fx, etc).  Three additional kinds
of keywords can also be specified (c_ID, f_ID, v_name), where a
<a class="reference internal" href="compute.html"><em>compute</em></a> or <a class="reference internal" href="fix.html"><em>fix</em></a> or <a class="reference internal" href="variable.html"><em>variable</em></a>
provides the values to be output.  In each case, the compute, fix, or
variable must generate per-atom values for input to the <a class="reference internal" href="dump.html"><em>dump custom</em></a> command.</p>
<p>There is also a <a class="reference internal" href="dump.html"><em>dump local</em></a> format where the user specifies
what local values to output.  A pre-defined index keyword can be
specified to enumuerate the local values.  Two additional kinds of
keywords can also be specified (c_ID, f_ID), where a
<a class="reference internal" href="compute.html"><em>compute</em></a> or <a class="reference internal" href="fix.html"><em>fix</em></a> or <a class="reference internal" href="variable.html"><em>variable</em></a>
provides the values to be output.  In each case, the compute or fix
must generate local values for input to the <a class="reference internal" href="dump.html"><em>dump local</em></a>
command.</p>
</div>
<div class="section" id="fixes-that-write-output-files">
<span id="fixoutput"></span><h3>8.8.5. Fixes that write output files<a class="headerlink" href="#fixes-that-write-output-files" title="Permalink to this headline">¶</a></h3>
<p>Several fixes take various quantities as input and can write output
files: <a class="reference internal" href="fix_ave_time.html"><em>fix ave/time</em></a>, <a class="reference internal" href="fix_ave_spatial.html"><em>fix ave/spatial</em></a>, <a class="reference internal" href="fix_ave_histo.html"><em>fix ave/histo</em></a>,
<a class="reference internal" href="fix_ave_correlate.html"><em>fix ave/correlate</em></a>, and <a class="reference internal" href="fix_print.html"><em>fix print</em></a>.</p>
<p>The <a class="reference internal" href="fix_ave_time.html"><em>fix ave/time</em></a> command enables direct output to
a file and/or time-averaging of global scalars or vectors.  The user
specifies one or more quantities as input.  These can be global
<a class="reference internal" href="compute.html"><em>compute</em></a> values, global <a class="reference internal" href="fix.html"><em>fix</em></a> values, or
<a class="reference internal" href="variable.html"><em>variables</em></a> of any style except the atom style which
produces per-atom values.  Since a variable can refer to keywords used
by the <a class="reference internal" href="thermo_style.html"><em>thermo_style custom</em></a> command (like temp or
press) and individual per-atom values, a wide variety of quantities
can be time averaged and/or output in this way.  If the inputs are one
or more scalar values, then the fix generate a global scalar or vector
of output.  If the inputs are one or more vector values, then the fix
generates a global vector or array of output.  The time-averaged
output of this fix can also be used as input to other output commands.</p>
<p>The <a class="reference internal" href="fix_ave_spatial.html"><em>fix ave/spatial</em></a> command enables direct
output to a file of spatial-averaged per-atom quantities like those
output in dump files, within 1d layers of the simulation box.  The
per-atom quantities can be atom density (mass or number) or atom
attributes such as position, velocity, force.  They can also be
per-atom quantities calculated by a <a class="reference internal" href="compute.html"><em>compute</em></a>, by a
<a class="reference internal" href="fix.html"><em>fix</em></a>, or by an atom-style <a class="reference internal" href="variable.html"><em>variable</em></a>.  The
spatial-averaged output of this fix can also be used as input to other
output commands.</p>
<p>The <a class="reference internal" href="fix_ave_histo.html"><em>fix ave/histo</em></a> command enables direct output
to a file of histogrammed quantities, which can be global or per-atom
or local quantities.  The histogram output of this fix can also be
used as input to other output commands.</p>
<p>The <a class="reference internal" href="fix_ave_correlate.html"><em>fix ave/correlate</em></a> command enables direct
output to a file of time-correlated quantities, which can be global
scalars.  The correlation matrix output of this fix can also be used
as input to other output commands.</p>
<p>The <a class="reference internal" href="fix_print.html"><em>fix print</em></a> command can generate a line of output
written to the screen and log file or to a separate file, periodically
during a running simulation.  The line can contain one or more
<a class="reference internal" href="variable.html"><em>variable</em></a> values for any style variable except the atom
style).  As explained above, variables themselves can contain
references to global values generated by <a class="reference internal" href="thermo_style.html"><em>thermodynamic keywords</em></a>, <a class="reference internal" href="compute.html"><em>computes</em></a>,
<a class="reference internal" href="fix.html"><em>fixes</em></a>, or other <a class="reference internal" href="variable.html"><em>variables</em></a>, or to per-atom
values for a specific atom.  Thus the <a class="reference internal" href="fix_print.html"><em>fix print</em></a>
command is a means to output a wide variety of quantities separate
from normal thermodynamic or dump file output.</p>
</div>
<div class="section" id="computes-that-process-output-quantities">
<span id="computeoutput"></span><h3>8.8.6. Computes that process output quantities<a class="headerlink" href="#computes-that-process-output-quantities" title="Permalink to this headline">¶</a></h3>
<p>The <a class="reference internal" href="compute_reduce.html"><em>compute reduce</em></a> and <a class="reference internal" href="compute_reduce.html"><em>compute reduce/region</em></a> commands take one or more per-atom
or local vector quantities as inputs and &#8220;reduce&#8221; them (sum, min, max,
ave) to scalar quantities.  These are produced as output values which
can be used as input to other output commands.</p>
<p>The <a class="reference internal" href="compute_slice.html"><em>compute slice</em></a> command take one or more global
vector or array quantities as inputs and extracts a subset of their
values to create a new vector or array.  These are produced as output
values which can be used as input to other output commands.</p>
<p>The <a class="reference internal" href="compute_property_atom.html"><em>compute property/atom</em></a> command takes a
list of one or more pre-defined atom attributes (id, x, fx, etc) and
stores the values in a per-atom vector or array.  These are produced
as output values which can be used as input to other output commands.
The list of atom attributes is the same as for the <a class="reference internal" href="dump.html"><em>dump custom</em></a> command.</p>
<p>The <a class="reference internal" href="compute_property_local.html"><em>compute property/local</em></a> command takes
a list of one or more pre-defined local attributes (bond info, angle
info, etc) and stores the values in a local vector or array.  These
are produced as output values which can be used as input to other
output commands.</p>
<p>The <a class="reference internal" href="compute_atom_molecule.html"><em>compute atom/molecule</em></a> command takes a
list of one or more per-atom quantities (from a compute, fix, per-atom
variable) and sums the quantities on a per-molecule basis.  It
produces a global vector or array as output values which can be used
as input to other output commands.</p>
</div>
<div class="section" id="fixes-that-process-output-quantities">
<span id="id1"></span><h3>8.8.7. Fixes that process output quantities<a class="headerlink" href="#fixes-that-process-output-quantities" title="Permalink to this headline">¶</a></h3>
<p>The <a class="reference internal" href="fix_ave_atom.html"><em>fix ave/atom</em></a> command performs time-averaging
of per-atom vectors.  The per-atom quantities can be atom attributes
such as position, velocity, force.  They can also be per-atom
quantities calculated by a <a class="reference internal" href="compute.html"><em>compute</em></a>, by a
<a class="reference internal" href="fix.html"><em>fix</em></a>, or by an atom-style <a class="reference internal" href="variable.html"><em>variable</em></a>.  The
time-averaged per-atom output of this fix can be used as input to
other output commands.</p>
<p>The <a class="reference internal" href="fix_store_state.html"><em>fix store/state</em></a> command can archive one or
more per-atom attributes at a particular time, so that the old values
can be used in a future calculation or output.  The list of atom
attributes is the same as for the <a class="reference internal" href="dump.html"><em>dump custom</em></a> command,
including per-atom quantities calculated by a <a class="reference internal" href="compute.html"><em>compute</em></a>,
by a <a class="reference internal" href="fix.html"><em>fix</em></a>, or by an atom-style <a class="reference internal" href="variable.html"><em>variable</em></a>.
The output of this fix can be used as input to other output commands.</p>
</div>
<div class="section" id="computes-that-generate-values-to-output">
<span id="compute"></span><h3>8.8.8. Computes that generate values to output<a class="headerlink" href="#computes-that-generate-values-to-output" title="Permalink to this headline">¶</a></h3>
<p>Every <a class="reference internal" href="compute.html"><em>compute</em></a> in LIGGGHTS(R)-PUBLIC produces either global or
per-atom or local values.  The values can be scalars or vectors or
arrays of data.  These values can be output using the other commands
described in this section.  The doc page for each compute command
describes what it produces.  Computes that produce per-atom or local
values have the word &#8220;atom&#8221; or &#8220;local&#8221; in their style name.  Computes
without the word &#8220;atom&#8221; or &#8220;local&#8221; produce global values.</p>
</div>
<div class="section" id="fixes-that-generate-values-to-output">
<span id="fix"></span><h3>8.8.9. Fixes that generate values to output<a class="headerlink" href="#fixes-that-generate-values-to-output" title="Permalink to this headline">¶</a></h3>
<p>Some <a class="reference internal" href="fix.html"><em>fixes</em></a> in LIGGGHTS(R)-PUBLIC produces either global or per-atom or
local values which can be accessed by other commands.  The values can
be scalars or vectors or arrays of data.  These values can be output
using the other commands described in this section.  The doc page for
each fix command tells whether it produces any output quantities and
describes them.</p>
</div>
<div class="section" id="variables-that-generate-values-to-output">
<span id="variable"></span><h3>8.8.10. Variables that generate values to output<a class="headerlink" href="#variables-that-generate-values-to-output" title="Permalink to this headline">¶</a></h3>
<p>Every <a class="reference internal" href="variable.html"><em>variables</em></a> defined in an input script generates
either a global scalar value or a per-atom vector (only atom-style
variables) when it is accessed.  The formulas used to define equal-
and atom-style variables can contain references to the thermodynamic
keywords and to global and per-atom data generated by computes, fixes,
and other variables.  The values generated by variables can be output
using the other commands described in this section.</p>
</div>
<div class="section" id="summary-table-of-output-options-and-data-flow-between-commands">
<span id="table"></span><h3>8.8.11. Summary table of output options and data flow between commands<a class="headerlink" href="#summary-table-of-output-options-and-data-flow-between-commands" title="Permalink to this headline">¶</a></h3>
<p>This table summarizes the various commands that can be used for
generating output from LIGGGHTS(R)-PUBLIC.  Each command produces output data of
some kind and/or writes data to a file.  Most of the commands can take
data from other commands as input.  Thus you can link many of these
commands together in pipeline form, where data produced by one command
is used as input to another command and eventually written to the
screen or to a file.  Note that to hook two commands together the
output and input data types must match, e.g. global/per-atom/local
data and scalar/vector/array data.</p>
<p>Also note that, as described above, when a command takes a scalar as
input, that could be an element of a vector or array.  Likewise a
vector input could be a column of an array.</p>
<table border="1" class="docutils">
<colgroup>
<col width="39%" />
<col width="30%" />
<col width="30%" />
<col width="1%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td>Command</td>
<td>Input</td>
<td>Output</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="thermo_style.html"><em>thermo_style custom</em></a></td>
<td>global scalars</td>
<td>screen, log file</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="dump.html"><em>dump custom</em></a></td>
<td>per-atom vectors</td>
<td>dump file</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="dump.html"><em>dump local</em></a></td>
<td>local vectors</td>
<td>dump file</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="fix_print.html"><em>fix print</em></a></td>
<td>global scalar from variable</td>
<td>screen, file</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="print.html"><em>print</em></a></td>
<td>global scalar from variable</td>
<td>screen</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="compute.html"><em>computes</em></a></td>
<td>N/A</td>
<td>global/per-atom/local scalar/vector/array</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="fix.html"><em>fixes</em></a></td>
<td>N/A</td>
<td>global/per-atom/local scalar/vector/array</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="variable.html"><em>variables</em></a></td>
<td>global scalars, per-atom vectors</td>
<td>global scalar, per-atom vector</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="compute_reduce.html"><em>compute reduce</em></a></td>
<td>per-atom/local vectors</td>
<td>global scalar/vector</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="compute_slice.html"><em>compute slice</em></a></td>
<td>global vectors/arrays</td>
<td>global vector/array</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="compute_property_atom.html"><em>compute property/atom</em></a></td>
<td>per-atom vectors</td>
<td>per-atom vector/array</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="compute_property_local.html"><em>compute property/local</em></a></td>
<td>local vectors</td>
<td>local vector/array</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="compute_atom_molecule.html"><em>compute atom/molecule</em></a></td>
<td>per-atom vectors</td>
<td>global vector/array</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="fix_ave_atom.html"><em>fix ave/atom</em></a></td>
<td>per-atom vectors</td>
<td>per-atom vector/array</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="fix_ave_time.html"><em>fix ave/time</em></a></td>
<td>global scalars/vectors</td>
<td>global scalar/vector/array, file</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="fix_ave_spatial.html"><em>fix ave/spatial</em></a></td>
<td>per-atom vectors</td>
<td>global array, file</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="fix_ave_histo.html"><em>fix ave/histo</em></a></td>
<td>global/per-atom/local scalars and vectors</td>
<td>global array, file</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="fix_ave_correlate.html"><em>fix ave/correlate</em></a></td>
<td>global scalars</td>
<td>global array, file</td>
<td>&nbsp;</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="fix_store_state.html"><em>fix store/state</em></a></td>
<td>per-atom vectors</td>
<td>per-atom vector/array</td>
<td>&nbsp;</td>
</tr>
<tr class="row-odd"><td>&nbsp;</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
</tr>
</tbody>
</table>
<hr class="docutils" />
</div>
</div>
<div class="section" id="walls">
<span id="howto-9"></span><h2><a class="toc-backref" href="#id70">8.9. Walls</a><a class="headerlink" href="#walls" title="Permalink to this headline">¶</a></h2>
<p>Walls are typically used to bound particle motion,
i.e. to serve as a boundary condition.</p>
<p>Walls in LIGGGHTS(R)-PUBLIC for granular simulations are
typically defined using <a class="reference internal" href="fix_wall_gran.html"><em>fix wall/gran</em></a>.
This command can define two types of
walls: primitive and mesh. Mesh walls are defined using a
<a class="reference internal" href="fix_mesh_surface.html"><em>fix mesh/surface</em></a> or related command.</p>
<p>Also. walls can be constructed made of particles</p>
<p>Rough walls, built of particles, can be created in various ways.  The
particles themselves can be generated like any other particle, via the
<a class="reference internal" href="lattice.html"><em>lattice</em></a> and <a class="reference internal" href="create_atoms.html"><em>create_atoms</em></a> commands,
or read in via the <a class="reference internal" href="read_data.html"><em>read_data</em></a> command.</p>
<p>Their motion can be constrained by many different commands, so that
they do not move at all, move together as a group at constant velocity
or in response to a net force acting on them, move in a prescribed
fashion (e.g. rotate around a point), etc.  Note that if a time
integration fix like <a class="reference internal" href="fix_nve.html"><em>fix nve</em></a>
is not used with the group that contains wall particles, their
positions and velocities will not be updated.</p>
<ul class="simple">
<li><a class="reference internal" href="fix_aveforce.html"><em>fix aveforce</em></a> - set force on particles to average value, so they move together</li>
<li><a class="reference internal" href="fix_setforce.html"><em>fix setforce</em></a> - set force on particles to a value, e.g. 0.0</li>
<li><a class="reference internal" href="fix_freeze.html"><em>fix freeze</em></a> - freeze particles for use as granular walls</li>
<li><a class="reference internal" href="fix_nve_noforce.html"><em>fix nve/noforce</em></a> - advect particles by their velocity, but without force</li>
<li><a class="reference internal" href="fix_move.html"><em>fix move</em></a> - prescribe motion of particles by a linear velocity, oscillation, rotation, variable</li>
</ul>
<p>The <a class="reference internal" href="fix_move.html"><em>fix move</em></a> command offers the most generality, since
the motion of individual particles can be specified with
<a class="reference internal" href="variable.html"><em>variable</em></a> formula which depends on time and/or the
particle position.</p>
<p>For rough walls, it may be useful to turn off pairwise interactions
between wall particles via the <a class="reference internal" href="neigh_modify.html"><em>neigh_modify exclude</em></a> command.</p>
<p>Rough walls can also be created by specifying frozen particles that do
not move and do not interact with mobile particles, and then tethering
other particles to the fixed particles, via a <a class="reference internal" href="bond_style.html"><em>bond</em></a>.
The bonded particles do interact with other mobile particles.</p>
<ul class="simple">
<li><a class="reference internal" href="fix_wall_reflect.html"><em>fix wall/reflect</em></a> - reflective flat walls</li>
<li><a class="reference internal" href="fix_wall_region.html"><em>fix wall/region</em></a> - use region surface as wall</li>
</ul>
<p>The <a class="reference internal" href="fix_wall_region.html"><em>fix wall/region</em></a> command offers the most
generality, since the region surface is treated as a wall, and the
geometry of the region can be a simple primitive volume (e.g. a
sphere, or cube, or plane), or a complex volume made from the union
and intersection of primitive volumes.  <a class="reference internal" href="region.html"><em>Regions</em></a> can also
specify a volume &#8220;interior&#8221; or &#8220;exterior&#8221; to the specified primitive
shape or <em>union</em> or <em>intersection</em>.  <a class="reference internal" href="region.html"><em>Regions</em></a> can also be
&#8220;dynamic&#8221; meaning they move with constant velocity, oscillate, or
rotate.</p>
<hr class="docutils" />
</div>
<div class="section" id="library-interface-to-liggghts-r-public">
<span id="howto-10"></span><h2><a class="toc-backref" href="#id71">8.10. Library interface to LIGGGHTS(R)-PUBLIC</a><a class="headerlink" href="#library-interface-to-liggghts-r-public" title="Permalink to this headline">¶</a></h2>
<p>As described in <a class="reference internal" href="Section_start.html#start-5"><span>Section_start 5</span></a>, LIGGGHTS(R)-PUBLIC
can be built as a library, so that it can be called by another code,
used in a <a class="reference internal" href="#howto-10"><span>coupled manner</span></a> with other
codes, or driven through a <a class="reference internal" href="Section_python.html"><em>Python interface</em></a>.</p>
<p>All of these methodologies use a C-style interface to LIGGGHTS(R)-PUBLIC that is
provided in the files src/library.cpp and src/library.h.  The
functions therein have a C-style argument list, but contain C++ code
you could write yourself in a C++ application that was invoking LIGGGHTS(R)-PUBLIC
directly.  The C++ code in the functions illustrates how to invoke
internal LIGGGHTS(R)-PUBLIC operations.  Note that LIGGGHTS(R)-PUBLIC classes are defined
within a LIGGGHTS(R)-PUBLIC namespace (LAMMPS_NS) if you use them from another C++
application.</p>
<p>Library.cpp contains these 4 functions:</p>
<div class="highlight-python"><div class="highlight"><pre>void lammps_open(int, char **, MPI_Comm, void **);
void lammps_close(void *);
void lammps_file(void *, char *);
char *lammps_command(void *, char *);
</pre></div>
</div>
<p>The lammps_open() function is used to initialize LIGGGHTS(R)-PUBLIC, passing in a
list of strings as if they were <a class="reference internal" href="Section_start.html#start-7"><span>command-line arguments</span></a> when LIGGGHTS(R)-PUBLIC is run in
stand-alone mode from the command line, and a MPI communicator for
LIGGGHTS(R)-PUBLIC to run under.  It returns a ptr to the LIGGGHTS(R)-PUBLIC object that is
created, and which is used in subsequent library calls.  The
lammps_open() function can be called multiple times, to create
multiple instances of LIGGGHTS(R)-PUBLIC.</p>
<p>LIGGGHTS(R)-PUBLIC will run on the set of processors in the communicator.  This
means the calling code can run LIGGGHTS(R)-PUBLIC on all or a subset of
processors.  For example, a wrapper script might decide to alternate
between LIGGGHTS(R)-PUBLIC and another code, allowing them both to run on all the
processors.  Or it might allocate half the processors to LIGGGHTS(R)-PUBLIC and
half to the other code and run both codes simultaneously before
syncing them up periodically.  Or it might instantiate multiple
instances of LIGGGHTS(R)-PUBLIC to perform different calculations.</p>
<p>The lammps_close() function is used to shut down an instance of LIGGGHTS(R)-PUBLIC
and free all its memory.</p>
<p>The lammps_file() and lammps_command() functions are used to pass a
file or string to LIGGGHTS(R)-PUBLIC as if it were an input script or single
command in an input script.  Thus the calling code can read or
generate a series of LIGGGHTS(R)-PUBLIC commands one line at a time and pass it
thru the library interface to setup a problem and then run it,
interleaving the lammps_command() calls with other calls to extract
information from LIGGGHTS(R)-PUBLIC, perform its own operations, or call another
code&#8217;s library.</p>
<p>Other useful functions are also included in library.cpp.  For example:</p>
<div class="highlight-python"><div class="highlight"><pre>void *lammps_extract_global(void *, char *)
void *lammps_extract_atom(void *, char *)
void *lammps_extract_compute(void *, char *, int, int)
void *lammps_extract_fix(void *, char *, int, int, int, int)
void *lammps_extract_variable(void *, char *, char *)
int lammps_get_natoms(void *)
void lammps_get_coords(void *, double *)
void lammps_put_coords(void *, double *)
</pre></div>
</div>
<p>These can extract various global or per-atom quantities from LIGGGHTS(R)-PUBLIC as
well as values calculated by a compute, fix, or variable.  The &#8220;get&#8221;
and &#8220;put&#8221; operations can retrieve and reset atom coordinates.
See the library.cpp file and its associated header file library.h for
details.</p>
<p>The key idea of the library interface is that you can write any
functions you wish to define how your code talks to LIGGGHTS(R)-PUBLIC and add
them to src/library.cpp and src/library.h, as well as to the <a class="reference internal" href="Section_python.html"><em>Python interface</em></a>.  The routines you add can access or
change any LIGGGHTS(R)-PUBLIC data you wish.  The examples/COUPLE and python
directories have example C++ and C and Python codes which show how a
driver code can link to LIGGGHTS(R)-PUBLIC as a library, run LIGGGHTS(R)-PUBLIC on a subset of
processors, grab data from LIGGGHTS(R)-PUBLIC, change it, and put it back into
LIGGGHTS(R)-PUBLIC.</p>
<p id="berendsen"><strong>(Berendsen)</strong> Berendsen, Grigera, Straatsma, J Phys Chem, 91,
6269-6271 (1987).</p>
<p id="cornell"><strong>(Cornell)</strong> Cornell, Cieplak, Bayly, Gould, Merz, Ferguson,
Spellmeyer, Fox, Caldwell, Kollman, JACS 117, 5179-5197 (1995).</p>
<p id="horn"><strong>(Horn)</strong> Horn, Swope, Pitera, Madura, Dick, Hura, and Head-Gordon,
J Chem Phys, 120, 9665 (2004).</p>
<p id="ikeshoji"><strong>(Ikeshoji)</strong> Ikeshoji and Hafskjold, Molecular Physics, 81, 251-261
(1994).</p>
<p id="mackerell"><strong>(MacKerell)</strong> MacKerell, Bashford, Bellott, Dunbrack, Evanseck, Field,
Fischer, Gao, Guo, Ha, et al, J Phys Chem, 102, 3586 (1998).</p>
<p id="mayo"><strong>(Mayo)</strong> Mayo, Olfason, Goddard III, J Phys Chem, 94, 8897-8909
(1990).</p>
<p id="jorgensen"><strong>(Jorgensen)</strong> Jorgensen, Chandrasekhar, Madura, Impey, Klein, J Chem
Phys, 79, 926 (1983).</p>
<p id="price"><strong>(Price)</strong> Price and Brooks, J Chem Phys, 121, 10096 (2004).</p>
<p id="shinoda"><strong>(Shinoda)</strong> Shinoda, Shiga, and Mikami, Phys Rev B, 69, 134103 (2004).</p>
</div>
</div>


           </div>
           <div class="articleComments">
            
           </div>
          </div>
          <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="Section_modify.html" class="btn btn-neutral float-right" title="9. Modifying &amp; extending LIGGGHTS(R)-PUBLIC" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
      
      
        <a href="Section_packages.html" class="btn btn-neutral" title="7. Packages" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
      
    </div>
  

  <hr/>

  <div role="contentinfo">
    <p>
        &copy; Copyright 2016, DCS Computing GmbH, JKU Linz and Sandia Corporation.

    </p>
  </div>
  Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 

</footer>

        </div>
      </div>

    </section>

  </div>
  


  

    <script type="text/javascript">
        var DOCUMENTATION_OPTIONS = {
            URL_ROOT:'./',
            VERSION:'v3.X',
            LANGUAGE:'None',
            COLLAPSE_INDEX:false,
            FILE_SUFFIX:'.html',
            HAS_SOURCE:  true,
            SOURCELINK_SUFFIX: ''
        };
    </script>
      <script type="text/javascript" src="_static/jquery.js"></script>
      <script type="text/javascript" src="_static/underscore.js"></script>
      <script type="text/javascript" src="_static/doctools.js"></script>

  

  
  
    <script type="text/javascript" src="_static/js/theme.js"></script>
  

  
  
  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.StickyNav.enable();
      });
  </script>
   

</body>
</html>